파이썬 클린코드 | 4장 SOLID 원칙

단일 책임 원칙(Single responsibility)

너무 많은 책임을 가진 클래스

class SystemMonitor:
	def load_activity(self):
		"""소스에서 처리할 이벤트 가져오기"""

	def identify_events(self):
		"""가져온 데이터를 파싱하여 도메인 객체 이벤트로 변환"""

	def stream_event(self):
		"""파싱한 이벤트를 외부 에이전트로 전송"""

책임 분산

개방-패쇄 원칙(Open-close)

개방-패쇄 원칙을 따르지 않을 경우 유지보수의 어려움

@dataclass
class Event:
	raw_data: dict

class UnknownEvent(Event):
	"""데이터만으로 식별할 수 없는 이벤트"""

class LoginEvent(Event):
	"""로그인 사용자에 의한 이벤트"""

class LogoutEvent(Event):
	"""로그아웃 사용자에 의한 이벤트"""

class SystemMonitor:
	"""시스템에서 발생한 이벤트 분류"""
	def __init__(self, event_data):
		self.event_data = event_data

	def identify_event(self):
		if (
			self.event_data["before"]["session"] == 0
			and self.event_data["after"]["session"] == 1
		):
			return LoginEvent(self.event_data)
		elif (
			self.event_data["before"]["session"] == 1
			and self.event_data["after"]["session"] == 0
		):
			return LogoutEvent(self.event_data)

		return UnknownEvent(self.event_data)
		# None을 반환하지 않고 UnknownEvent를 반환하는 것은 다형성을 보장하기 위함이다(null 객체 패턴)

>>> 11 = SystemMonitor({"before": {"session": 0}, "after": {"session": 1}})
>>> 11.identify_event().__class__.__name__
"LoginEvent"

>>> 12 = SystemMonitor({"before": {"session": 1}, "after": {"session": 0}})
>>> 12.identify_event().__class__.__name__
"LogoutEvent"

>>> 13 = SystemMonitor({"before": {"session": 1}, "after": {"session": 1}})
>>> 13.identify_event().__class__.__name__
"UnknownEvent"

1. 이벤트 유형을 결정하는 로직이 단일 메서드(identify_event)에 집중되어 있다. - 지원하는 이벤트가 늘어날수록 메서드도 커지게 된다.

2. 새로운 이벤트 시스템을 추가할때마다 메서드를 수정해야 한다 - elif 문은 계속 늘어나면서 가독성을 망친다.

• 개방: 새로운 이벤트가 추가될때 기존 코드를 변경하지 않고 확장하여 새로운 유형의 이벤트를 지원하고 싶다.

• 패쇄: 메서드를 변경하지 않고 새로운 유형의 이벤트를 추가하고 싶다.

확장성을 가진 이벤트 시스템으로 리팩터링

class Event:
	def __init__(self, raw_data):
		self.raw_data = raw_data

	@staticmethod
	def meets_condition(event_data: dict) -> bool:
		return False

class UnknownEvent(Event):
	...

class LoginEvent(Event):
	@staticmethod
	def meets_condition(event_data: dict):
		return (
			self.event_data["before"]["session"] == 0
			and self.event_data["after"]["session"] == 1
		)

class LogoutEvent(Event):
	@staticmethod
	def meets_condition(event_data: dict):
		return (
			self.event_data["before"]["session"] == 1
			and self.event_data["after"]["session"] == 0
		)

class SystemMonitor(Event):
	def __init__(self, event_data):
		self.event_data = event_data

	def identify_event(self):
		for event_cls in Event.__subclasses__():
			try:
				if event_cls.meets_condition(self.event_data):
					return event_cls(self.event_data)
			except KeyError:
				continue

		return UnkownEvent(self.event_data)

이벤트 시스템 확장

class TransactionEvent(Event):
	@staticmethod
	def meets_condition(event_data: dict):
		return event_data["after"].get("transaction") is not None

>>> 14 = SystemMonitor({"after": {"transaction": "Tx001"}})
>>> 14.identify_event().__class__.__name__
"TransactionEvent"

최종 정리

리스코프 치환 원칙(Liskov’s subsitution)

도구를 사용해 LSP 문제 검사하기

class Event:
	...
	def meets_condition(self, event_data: dict) -> bool:
		return False

class LoginEvent(Event):
	def meets_condition(self, event_data: list) -> bool:
		return bool(evnet_data)		

error: Argument 1 of "meets_condition" incompatible with supertype "Event"

pylint로 호환되지 않는 서명 검사

class LogoutEvnet(Event):
	def meets_condition(self, event_data: dict, override: bool) -> bool:
		if override:
			return True
		
		....

Parameters differ from overridden "meets_condition" method (arguments-differ)

애매한 LSP 위반 사례

• 하위 클래스는 부모 클래스에 정의된 것보다 사전조건을 엄격하게 만들면 안된다.

• 하위 클래스는 부모 클래스에 정의된 것보다 약한 사후조건을 만들면 안된다.

from collections.abc import Mapping

class Event:
	def __init__(self, raw_data):
		self.raw_data = raw_data

	@staticmethod
	def meets_condition(event_data: dict) -> bool:
		return False

	@staticmethod
	def validate_precondition(evnet_data: dict):
		"""인터페이스 계약의 사전조건
			'event_data' 파라미터가 적절한 형태인지 유효성 검사
		"""
		if not isinstance(event_data, Mapping):
			raise ValueError(f"{event_data!r} dict 데이터 타입이 아님")
		for moment in ("before", "after"):
			if moment not in event_data:
				raise ValueError(f"{event_data}에 {moment} 정보가 없음")
			if not isinstance(event_data[moment], Mapping):
				raise ValueError(f"event_data[moment!r] dict 데이터 타입이 아님!")

class SystemMonitor:
    """시스템에서 발생한 이벤트 분류"""

    def __init__(self, event_data):
        self.event_data = event_data

    def identify_event(self):
        Event.meets_condition_pre(self.event_data)
        event_cls = next(
            (
                event_cls
                for event_cls in Event.__subclasses__()
                if event_cls.meets_condition(self.event_data)
            ),
            UnknownEvent,
        )
        return event_cls(self.event_data)

최종 정리

인터페이스 분리 원칙 (Interface sergregation)

from abc import *

class EventParser(metaclass=ABCMeta):
		...

		@abstractmethod
		def from_xml(self, event_data):
				pass

		@abstractmethod
		def from_json(self, event_data):
				pass

• from_json()만을 필요로 하는 클라이언트에게 from_xml()까지 제공한다.

• 유연성을 떨어트리며, 필요하지 않은 메서드도 구현하게끔 강제한다.

from abc import ABCMeta, abstractmethod

class XMLEventParser(metaclass=ABCMeta):
		@abstractmethod
		def from_xml(xml_data: str):
				"""XML 형태의 데이터를 파싱"""

class JSONEventParser(metaclass=ABCMeta):
		@abstractmethod
		def from_json(xml_data: str):
				"""JSON 형태의 데이터를 파싱"""

class EventParser(XMLEventParser, JSONEventParser):
		"""XML 과 JSON 형태의 데이터를 파싱"""
		def from_xml(xml_data):
				pass

		def from_json(json_data):
				pass

### 추상메서드를 구현하지 않으면 런타임 에러
>>> from src.isp import EventParser
>>> EventParser()
Traceback(most recent call last):
		File "<stdin>", line 1, in <module>
TypeError: Can't instaniate abstract class EventParser with absteract
methods from_json, from_xml

• 인터페이스를 분리함으로서 필요로 하지 않는 메서드에 의존하게 되는 문제를 해결했다.

• 유연하게 조합할 수 있다.

의존성 역전

### DIP를 적용하지 않은 사례
class EventStreamer():
		def __init__(self):
				self._target = Syslog()

		def stream(self, events: list[Evnet]) -> None:
				for event in events:
						self._target.send(event.serialise())

• 고수준의 모듈이 저수준의 모듈을 참조함으로써, 저수준 모듈에 의존하고 있다.

• Syslog의 send() 함수가 변경되었을 때에는 EventStreamer 클래스도 변경해야 할 가능성이 생긴다.

• Syslog에 의존해 있으므로 단위테스트에서 문제가 생길 수 있다.

### DIP 적용 사례
class EventStreamer():
		def __init__(self, target: DataTargetClient):
				self._target = target

		def stream(self, events: list[Evnet]) -> None:
				for event in events:
						self._target.send(event.serialise())

• EventStreamer 클래스는 단지 DataTargetClient 인터페이스와 관계를 가질뿐, 의존성이 사라지게 된다.

• 단위테스트에서 테스트 더블을 사용해 제공하기만 하면 된다.